home *** CD-ROM | disk | FTP | other *** search
/ Turnbull China Bikeride / Turnbull China Bikeride - Disc 2.iso / BARNET / ARMTEX / SOURCES2 / !TeX / texmf / source / armTeX / web2c / c / lexyy < prev    next >
Encoding:
Text File  |  1998-03-15  |  52.0 KB  |  2,077 lines

  1. /* A lexical scanner generated by flex */
  2.  
  3. /* Scanner skeleton version:
  4.  * $Header: /home/daffy/u0/vern/flex/RCS/flex.skl,v 2.85 95/04/24 10:48:47 vern Exp $
  5.  */
  6.  
  7. #define FLEX_SCANNER
  8. #define YY_FLEX_MAJOR_VERSION 2
  9. #define YY_FLEX_MINOR_VERSION 5
  10.  
  11. #include <stdio.h>
  12.  
  13.  
  14. /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
  15. #ifdef c_plusplus
  16. #ifndef __cplusplus
  17. #define __cplusplus
  18. #endif
  19. #endif
  20.  
  21.  
  22. #ifdef __cplusplus
  23.  
  24. #include <stdlib.h>
  25. #include <unistd.h>
  26.  
  27. /* Use prototypes in function declarations. */
  28. #define YY_USE_PROTOS
  29.  
  30. /* The "const" storage-class-modifier is valid. */
  31. #define YY_USE_CONST
  32.  
  33. #else    /* ! __cplusplus */
  34.  
  35. #if __STDC__
  36.  
  37. #define YY_USE_PROTOS
  38. #define YY_USE_CONST
  39.  
  40. #endif    /* __STDC__ */
  41. #endif    /* ! __cplusplus */
  42.  
  43. /*#ifdef __TURBOC__
  44.  #pragma warn -rch
  45.  #pragma warn -use
  46. #include <io.h>
  47. #include <stdlib.h>
  48. #define YY_USE_CONST
  49. #define YY_USE_PROTOS
  50. #endif*/
  51.  
  52. #ifdef YY_USE_CONST
  53. #define yyconst const
  54. #else
  55. #define yyconst
  56. #endif
  57.  
  58.  
  59. #ifdef YY_USE_PROTOS
  60. #define YY_PROTO(proto) proto
  61. #else
  62. #define YY_PROTO(proto) ()
  63. #endif
  64.  
  65. /* Returned upon end-of-file. */
  66. #define YY_NULL 0
  67.  
  68. /* Promotes a possibly negative, possibly signed char to an unsigned
  69.  * integer for use as an array index.  If the signed char is negative,
  70.  * we want to instead treat it as an 8-bit unsigned char, hence the
  71.  * double cast.
  72.  */
  73. #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
  74.  
  75. /* Enter a start condition.  This macro really ought to take a parameter,
  76.  * but we do it the disgusting crufty way forced on us by the ()-less
  77.  * definition of BEGIN.
  78.  */
  79. #define BEGIN yy_start = 1 + 2 *
  80.  
  81. /* Translate the current start state into a value that can be later handed
  82.  * to BEGIN to return to the state.  The YYSTATE alias is for lex
  83.  * compatibility.
  84.  */
  85. #define YY_START ((yy_start - 1) / 2)
  86. #define YYSTATE YY_START
  87.  
  88. /* Action number for EOF rule of a given start state. */
  89. #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
  90.  
  91. /* Special action meaning "start processing a new file". */
  92. #define YY_NEW_FILE yyrestart( yyin )
  93.  
  94. #define YY_END_OF_BUFFER_CHAR 0
  95.  
  96. /* Size of default input buffer. */
  97. #define YY_BUF_SIZE 16384
  98.  
  99. typedef struct yy_buffer_state *YY_BUFFER_STATE;
  100.  
  101. extern int yyleng;
  102. extern FILE *yyin, *yyout;
  103.  
  104. #define EOB_ACT_CONTINUE_SCAN 0
  105. #define EOB_ACT_END_OF_FILE 1
  106. #define EOB_ACT_LAST_MATCH 2
  107.  
  108. /* The funky do-while in the following #define is used to turn the definition
  109.  * int a single C statement (which needs a semi-colon terminator).  This
  110.  * avoids problems with code like:
  111.  *
  112.  *     if ( condition_holds )
  113.  *        yyless( 5 );
  114.  *    else
  115.  *        do_something_else();
  116.  *
  117.  * Prior to using the do-while the compiler would get upset at the
  118.  * "else" because it interpreted the "if" statement as being all
  119.  * done when it reached the ';' after the yyless() call.
  120.  */
  121.  
  122. /* Return all but the first 'n' matched characters back to the input stream. */
  123.  
  124. #define yyless(n) \
  125.     do \
  126.         { \
  127.         /* Undo effects of setting up yytext. */ \
  128.         *yy_cp = yy_hold_char; \
  129.         yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
  130.         YY_DO_BEFORE_ACTION; /* set up yytext again */ \
  131.         } \
  132.     while ( 0 )
  133.  
  134. #define unput(c) yyunput( c, yytext_ptr )
  135.  
  136. /* The following is because we cannot portably get our hands on size_t
  137.  * (without autoconf's help, which isn't available because we want
  138.  * flex-generated scanners to compile on their own).
  139.  */
  140. typedef unsigned int yy_size_t;
  141.  
  142.  
  143. struct yy_buffer_state
  144.     {
  145.     FILE *yy_input_file;
  146.  
  147.     char *yy_ch_buf;        /* input buffer */
  148.     char *yy_buf_pos;        /* current position in input buffer */
  149.  
  150.     /* Size of input buffer in bytes, not including room for EOB
  151.      * characters.
  152.      */
  153.     yy_size_t yy_buf_size;
  154.  
  155.     /* Number of characters read into yy_ch_buf, not including EOB
  156.      * characters.
  157.      */
  158.     int yy_n_chars;
  159.  
  160.     /* Whether we "own" the buffer - i.e., we know we created it,
  161.      * and can realloc() it to grow it, and should free() it to
  162.      * delete it.
  163.      */
  164.     int yy_is_our_buffer;
  165.  
  166.     /* Whether this is an "interactive" input source; if so, and
  167.      * if we're using stdio for input, then we want to use getc()
  168.      * instead of fread(), to make sure we stop fetching input after
  169.      * each newline.
  170.      */
  171.     int yy_is_interactive;
  172.  
  173.     /* Whether we're considered to be at the beginning of a line.
  174.      * If so, '^' rules will be active on the next match, otherwise
  175.      * not.
  176.      */
  177.     int yy_at_bol;
  178.  
  179.     /* Whether to try to fill the input buffer when we reach the
  180.      * end of it.
  181.      */
  182.     int yy_fill_buffer;
  183.  
  184.     int yy_buffer_status;
  185. #define YY_BUFFER_NEW 0
  186. #define YY_BUFFER_NORMAL 1
  187.     /* When an EOF's been seen but there's still some text to process
  188.      * then we mark the buffer as YY_EOF_PENDING, to indicate that we
  189.      * shouldn't try reading from the input source any more.  We might
  190.      * still have a bunch of tokens to match, though, because of
  191.      * possible backing-up.
  192.      *
  193.      * When we actually see the EOF, we change the status to "new"
  194.      * (via yyrestart()), so that the user can continue scanning by
  195.      * just pointing yyin at a new input file.
  196.      */
  197. #define YY_BUFFER_EOF_PENDING 2
  198.     };
  199.  
  200. static YY_BUFFER_STATE yy_current_buffer = 0;
  201.  
  202. /* We provide macros for accessing buffer states in case in the
  203.  * future we want to put the buffer states in a more general
  204.  * "scanner state".
  205.  */
  206. #define YY_CURRENT_BUFFER yy_current_buffer
  207.  
  208.  
  209. /* yy_hold_char holds the character lost when yytext is formed. */
  210. static char yy_hold_char;
  211.  
  212. static int yy_n_chars;        /* number of characters read into yy_ch_buf */
  213.  
  214.  
  215. int yyleng;
  216.  
  217. /* Points to current character in buffer. */
  218. static char *yy_c_buf_p = (char *) 0;
  219. static int yy_init = 1;        /* whether we need to initialize */
  220. static int yy_start = 0;    /* start state number */
  221.  
  222. /* Flag which is used to allow yywrap()'s to do buffer switches
  223.  * instead of setting up a fresh yyin.  A bit of a hack ...
  224.  */
  225. static int yy_did_buffer_switch_on_eof;
  226.  
  227. void yyrestart YY_PROTO(( FILE *input_file ));
  228.  
  229. void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
  230. void yy_load_buffer_state YY_PROTO(( void ));
  231. YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
  232. void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
  233. void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
  234. void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
  235. #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
  236.  
  237. YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
  238. YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *str ));
  239. YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
  240.  
  241. static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
  242. static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
  243. static void yy_flex_free YY_PROTO(( void * ));
  244.  
  245. #define yy_new_buffer yy_create_buffer
  246.  
  247. #define yy_set_interactive(is_interactive) \
  248.     { \
  249.     if ( ! yy_current_buffer ) \
  250.         yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
  251.     yy_current_buffer->yy_is_interactive = is_interactive; \
  252.     }
  253.  
  254. #define yy_set_bol(at_bol) \
  255.     { \
  256.     if ( ! yy_current_buffer ) \
  257.         yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
  258.     yy_current_buffer->yy_at_bol = at_bol; \
  259.     }
  260.  
  261. #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
  262.  
  263.  
  264. #define yywrap() 1
  265. #define YY_SKIP_YYWRAP
  266. typedef unsigned char YY_CHAR;
  267. FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
  268. typedef int yy_state_type;
  269. extern char *yytext;
  270. #define yytext_ptr yytext
  271.  
  272. static yy_state_type yy_get_previous_state YY_PROTO(( void ));
  273. static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
  274. static int yy_get_next_buffer YY_PROTO(( void ));
  275. static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
  276.  
  277. /* Done after the current pattern has been matched and before the
  278.  * corresponding action - sets up yytext.
  279.  */
  280. #define YY_DO_BEFORE_ACTION \
  281.     yytext_ptr = yy_bp; \
  282.     yyleng = (int) (yy_cp - yy_bp); \
  283.     yy_hold_char = *yy_cp; \
  284.     *yy_cp = '\0'; \
  285.     yy_c_buf_p = yy_cp;
  286.  
  287. #define YY_NUM_RULES 71
  288. #define YY_END_OF_BUFFER 72
  289. static yyconst short int yy_accept[265] =
  290.     {   0,
  291.         0,    0,   72,   70,    1,    1,    3,   70,   58,   59,
  292.        50,   48,   65,   49,   64,   51,   45,   67,   66,   54,
  293.        52,   55,   70,   69,   60,   61,   68,   69,   69,   69,
  294.        69,   69,   69,   69,   69,   69,   69,   69,   69,   69,
  295.        69,   69,   69,   69,   69,   69,    2,    1,    0,    0,
  296.        47,   63,    0,   45,    0,   62,   56,   53,   57,    0,
  297.         0,   69,   69,   69,   69,   69,   69,   69,   69,   17,
  298.        69,   69,   69,   69,   69,   69,   69,   25,   69,   69,
  299.        69,   29,   30,   69,   69,   69,   69,   69,   38,   69,
  300.        69,   69,   69,    0,    0,   46,   44,    0,   44,    0,
  301.  
  302.         0,   10,   69,   69,   69,   69,   69,   15,   69,   69,
  303.        20,   69,   22,   69,   69,    0,    0,    0,   69,    0,
  304.        69,   69,   27,   28,   69,   69,   69,   69,   69,   69,
  305.        69,   69,   41,   69,    0,   47,    0,    0,    0,   69,
  306.        69,   69,   13,   69,   69,   19,   69,   21,   69,   24,
  307.         0,    0,    0,    0,    0,    0,    0,   69,    0,    0,
  308.        69,   69,   69,   69,   69,   69,   69,   69,   37,   39,
  309.        69,   69,    0,    0,   44,    0,    0,   11,   12,   16,
  310.        14,   69,   69,   69,    0,    0,    0,    0,   35,   36,
  311.         0,    0,    0,   69,   69,   26,   69,   69,   69,   69,
  312.  
  313.        69,   69,   40,   42,    0,    0,    9,   18,    5,   69,
  314.         0,    0,    0,    0,   69,    4,   43,   69,   69,   69,
  315.        33,   34,    0,    8,   69,    0,    0,   69,    1,   69,
  316.        32,   23,    0,    0,   69,   69,    0,    0,    0,   31,
  317.         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  318.         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  319.         7,    0,    6,    0
  320.     } ;
  321.  
  322. static yyconst int yy_ec[256] =
  323.     {   0,
  324.         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
  325.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  326.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  327.         1,    4,    1,    1,    5,    1,    1,    1,    6,    7,
  328.         8,    9,   10,   11,   12,   13,   14,   15,   16,   17,
  329.        17,   17,   17,   17,   17,   17,   17,   18,   19,   20,
  330.        21,   22,    1,   23,   24,   24,   24,   24,   24,   24,
  331.        24,   24,   24,   24,   24,   24,   24,   24,   24,   24,
  332.        24,   24,   24,   24,   24,   24,   24,   24,   24,   24,
  333.        25,    1,   26,   27,    1,    1,   28,   29,   30,   31,
  334.  
  335.        32,   33,   34,   35,   36,   37,   38,   39,   40,   41,
  336.        42,   43,   37,   44,   45,   46,   47,   48,   49,   37,
  337.        50,   37,   51,    1,   52,    1,    1,    1,    1,    1,
  338.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  339.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  340.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  341.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  342.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  343.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  344.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  345.  
  346.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  347.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  348.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  349.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  350.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  351.         1,    1,    1,    1,    1
  352.     } ;
  353.  
  354. static yyconst int yy_meta[53] =
  355.     {   0,
  356.         1,    1,    1,    1,    1,    1,    2,    2,    1,    1,
  357.         2,    1,    1,    1,    3,    3,    3,    2,    1,    1,
  358.         1,    1,    1,    3,    1,    1,    1,    4,    4,    4,
  359.         4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
  360.         4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
  361.         1,    1
  362.     } ;
  363.  
  364. static yyconst short int yy_base[274] =
  365.     {   0,
  366.         0,    0,  389,  390,   51,   54,  390,  382,  390,  390,
  367.       390,  390,  390,  390,  374,  390,   46,  365,  390,   43,
  368.       390,  364,   35,    0,  390,  390,  390,   26,   28,   41,
  369.        35,   34,   38,  342,  348,  349,  353,  338,  337,   43,
  370.        51,  346,   46,  336,  348,  340,  390,   88,  346,  367,
  371.       366,  390,   83,   88,   96,  390,  390,  390,  390,  339,
  372.       334,    0,  338,  324,  333,  334,  320,  323,  315,  313,
  373.       316,  329,  320,  314,  316,  310,  112,  324,  325,  322,
  374.       306,    0,    0,  316,  320,  307,   79,  316,    0,  304,
  375.       300,  301,  308,  313,  336,  335,  111,  117,  120,  307,
  376.  
  377.       307,    0,  310,  301,  308,  303,  289,    0,  292,  300,
  378.       295,  298,    0,  299,  286,  137,  318,  144,  298,  273,
  379.       292,  291,    0,    0,  290,  283,   52,  278,  287,  277,
  380.       285,  280,    0,  276,  276,  307,  142,  276,  272,  260,
  381.       268,  270,    0,  261,  260,    0,  272,    0,  258,    0,
  382.       275,  293,  162,  292,  102,  272,  247,  268,  245,  168,
  383.       263,  256,  250,  261,  260,  247,  246,  261,    0,    0,
  384.       249,  255,  254,  145,  161,  244,  253,    0,    0,    0,
  385.         0,  241,  275,  245,  249,  241,  241,  239,  390,  390,
  386.       217,  192,  194,  205,  235,    0,  196,  209,  208,  208,
  387.  
  388.       204,  188,    0,    0,  201,  199,  390,    0,  390,  188,
  389.       191,  219,  219,  188,  193,  390,    0,  214,  167,  172,
  390.         0,    0,  206,  390,  165,  168,  167,  163,  181,  149,
  391.         0,  188,  159,  158,  182,  150,    0,  175,  170,  164,
  392.       148,    0,  200,  137,  205,  111,  213,  105,  218,  103,
  393.        93,   94,  102,   80,   80,   95,   90,   66,   88,   71,
  394.       390,   74,  390,  390,  251,  253,  257,  261,  265,  269,
  395.       273,  276,   80
  396.     } ;
  397.  
  398. static yyconst short int yy_def[274] =
  399.     {   0,
  400.       264,    1,  264,  264,  264,  264,  264,  265,  264,  264,
  401.       264,  264,  264,  264,  264,  264,  264,  264,  264,  264,
  402.       264,  264,  264,  266,  264,  264,  264,  266,  266,  266,
  403.       266,  266,  266,  266,  266,  266,  266,  266,  266,  266,
  404.       266,  266,  266,  266,  266,  266,  264,  264,  264,  267,
  405.       264,  264,  264,  264,  264,  264,  264,  264,  264,  264,
  406.       264,  266,  266,  266,  266,  266,  266,  266,  266,  266,
  407.       266,  266,  266,  266,  266,  266,  266,  266,  266,  266,
  408.       266,  266,  266,  266,  266,  266,  266,  266,  266,  266,
  409.       266,  266,  266,  264,  267,  264,  264,  264,  264,  264,
  410.  
  411.       264,  266,  266,  266,  266,  266,  266,  266,  266,  266,
  412.       266,  266,  266,  266,  266,  264,  264,  264,  266,  268,
  413.       266,  266,  266,  266,  266,  266,  266,  266,  266,  266,
  414.       266,  266,  266,  266,  264,  264,  264,  264,  264,  266,
  415.       266,  266,  266,  266,  266,  266,  266,  266,  266,  266,
  416.       264,  269,  264,  264,  264,  264,  270,  266,  268,  264,
  417.       266,  266,  266,  266,  266,  266,  266,  266,  266,  266,
  418.       266,  266,  264,  264,  264,  264,  264,  266,  266,  266,
  419.       266,  266,  266,  266,  264,  269,  269,  271,  264,  264,
  420.       264,  270,  264,  266,  266,  266,  266,  266,  266,  266,
  421.  
  422.       266,  266,  266,  266,  264,  264,  264,  266,  264,  266,
  423.       264,  271,  271,  264,  266,  264,  266,  266,  266,  266,
  424.       266,  266,  264,  264,  266,  264,  264,  266,  264,  266,
  425.       266,  266,  264,  264,  266,  266,  272,  264,  264,  266,
  426.       272,  273,  264,  273,  264,  264,  264,  264,  264,  264,
  427.       264,  264,  264,  264,  264,  264,  264,  264,  264,  264,
  428.       264,  264,  264,    0,  264,  264,  264,  264,  264,  264,
  429.       264,  264,  264
  430.     } ;
  431.  
  432. static yyconst short int yy_nxt[443] =
  433.     {   0,
  434.         4,    5,    6,    5,    7,    8,    9,   10,   11,   12,
  435.        13,   14,   15,   16,   17,   17,   17,   18,   19,   20,
  436.        21,   22,   23,   24,   25,   26,   27,   28,   29,   30,
  437.        31,   32,   33,   34,   35,   36,   24,   24,   37,   38,
  438.        39,   40,   41,   42,   24,   43,   44,   45,   46,   24,
  439.        47,    4,   48,   48,   48,   48,   48,   48,   53,   65,
  440.        54,   54,   54,   57,   58,   60,   63,   61,   67,   64,
  441.        69,   66,   71,   73,   72,   82,   70,   55,   85,   74,
  442.        88,  165,   68,  244,   75,  166,   83,   89,   84,   48,
  443.        48,   48,  263,   49,   86,   90,   49,   97,   97,   97,
  444.  
  445.        53,  262,   54,   54,   54,   98,  261,   98,  128,  260,
  446.        99,   99,   99,  116,  116,  116,  189,  190,  117,   55,
  447.       259,  129,  258,  257,  118,   97,   97,   97,  256,  255,
  448.        49,   99,   99,   99,   99,   99,   99,  254,  116,  116,
  449.       116,  253,  137,  117,  252,  153,  153,  153,  251,  118,
  450.       154,  174,  248,  174,  119,  247,  175,  175,  175,  175,
  451.       175,  175,  120,  153,  153,  153,  243,  242,  154,  116,
  452.       116,  116,  155,  193,  117,  175,  175,  175,  160,  151,
  453.       118,  240,   48,   48,   48,  160,  156,  120,  239,  238,
  454.       155,  237,  236,  235,  157,  153,  153,  153,  234,  233,
  455.  
  456.       154,  245,  245,  245,  156,  232,  245,  245,  245,  229,
  457.       151,  231,  157,  230,  249,  249,  249,  229,  120,  249,
  458.       249,  249,  155,   49,  228,  227,  193,  213,  226,  225,
  459.       224,  223,  246,  222,  221,  220,  156,  246,  219,  218,
  460.       217,  216,  215,  193,  157,  250,  214,  213,  160,  187,
  461.       250,   50,   50,   50,   50,   62,   62,   95,   95,   95,
  462.        95,  159,  159,  159,  159,  186,  186,  186,  186,  192,
  463.       192,  192,  192,  212,  212,  212,  212,  241,  211,  241,
  464.       210,  209,  208,  207,  206,  205,  204,  203,  202,  201,
  465.       200,  199,  198,  197,  196,  195,  160,  194,  193,  191,
  466.  
  467.       188,  187,  185,  184,  183,  182,  181,  180,  179,  178,
  468.       177,  176,   95,  173,  172,  171,  170,  169,  168,  167,
  469.       164,  163,  162,  161,  160,  158,  152,  150,  149,  148,
  470.       147,  146,  145,  144,  143,  142,  141,  140,  139,  138,
  471.        95,  136,  135,  134,  133,  132,  131,  130,  127,  126,
  472.       125,  124,  123,  122,  121,  115,  114,  113,  112,  111,
  473.       110,  109,  108,  107,  106,  105,  104,  103,  102,  101,
  474.       100,   50,   96,   94,   93,   92,   91,   87,   81,   80,
  475.        79,   78,   77,   76,   59,   56,   52,   51,  264,    3,
  476.       264,  264,  264,  264,  264,  264,  264,  264,  264,  264,
  477.  
  478.       264,  264,  264,  264,  264,  264,  264,  264,  264,  264,
  479.       264,  264,  264,  264,  264,  264,  264,  264,  264,  264,
  480.       264,  264,  264,  264,  264,  264,  264,  264,  264,  264,
  481.       264,  264,  264,  264,  264,  264,  264,  264,  264,  264,
  482.       264,  264
  483.     } ;
  484.  
  485. static yyconst short int yy_chk[443] =
  486.     {   0,
  487.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  488.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  489.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  490.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  491.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  492.         1,    1,    5,    5,    5,    6,    6,    6,   17,   29,
  493.        17,   17,   17,   20,   20,   23,   28,   23,   30,   28,
  494.        31,   29,   32,   33,   32,   40,   31,   17,   41,   33,
  495.        43,  127,   30,  273,   33,  127,   40,   43,   40,   48,
  496.        48,   48,  262,    5,   41,   43,    6,   53,   53,   53,
  497.  
  498.        54,  260,   54,   54,   54,   55,  259,   55,   87,  258,
  499.        55,   55,   55,   77,   77,   77,  155,  155,   77,   54,
  500.       257,   87,  256,  255,   77,   97,   97,   97,  254,  253,
  501.        48,   98,   98,   98,   99,   99,   99,  252,  116,  116,
  502.       116,  251,   97,  116,  250,  118,  118,  118,  248,  116,
  503.       118,  137,  246,  137,   77,  244,  137,  137,  137,  174,
  504.       174,  174,   77,  153,  153,  153,  241,  240,  153,  160,
  505.       160,  160,  118,  239,  160,  175,  175,  175,  238,  116,
  506.       160,  236,  229,  229,  229,  235,  118,  116,  234,  233,
  507.       153,  232,  230,  228,  118,  193,  193,  193,  227,  226,
  508.  
  509.       193,  243,  243,  243,  153,  225,  245,  245,  245,  223,
  510.       160,  220,  153,  219,  247,  247,  247,  218,  160,  249,
  511.       249,  249,  193,  229,  215,  214,  213,  212,  211,  210,
  512.       206,  205,  243,  202,  201,  200,  193,  245,  199,  198,
  513.       197,  195,  194,  192,  193,  247,  191,  188,  187,  186,
  514.       249,  265,  265,  265,  265,  266,  266,  267,  267,  267,
  515.       267,  268,  268,  268,  268,  269,  269,  269,  269,  270,
  516.       270,  270,  270,  271,  271,  271,  271,  272,  185,  272,
  517.       184,  183,  182,  177,  176,  173,  172,  171,  168,  167,
  518.       166,  165,  164,  163,  162,  161,  159,  158,  157,  156,
  519.  
  520.       154,  152,  151,  149,  147,  145,  144,  142,  141,  140,
  521.       139,  138,  136,  135,  134,  132,  131,  130,  129,  128,
  522.       126,  125,  122,  121,  120,  119,  117,  115,  114,  112,
  523.       111,  110,  109,  107,  106,  105,  104,  103,  101,  100,
  524.        96,   95,   94,   93,   92,   91,   90,   88,   86,   85,
  525.        84,   81,   80,   79,   78,   76,   75,   74,   73,   72,
  526.        71,   70,   69,   68,   67,   66,   65,   64,   63,   61,
  527.        60,   51,   50,   49,   46,   45,   44,   42,   39,   38,
  528.        37,   36,   35,   34,   22,   18,   15,    8,    3,  264,
  529.       264,  264,  264,  264,  264,  264,  264,  264,  264,  264,
  530.  
  531.       264,  264,  264,  264,  264,  264,  264,  264,  264,  264,
  532.       264,  264,  264,  264,  264,  264,  264,  264,  264,  264,
  533.       264,  264,  264,  264,  264,  264,  264,  264,  264,  264,
  534.       264,  264,  264,  264,  264,  264,  264,  264,  264,  264,
  535.       264,  264
  536.     } ;
  537.  
  538. static yy_state_type yy_last_accepting_state;
  539. static char *yy_last_accepting_cpos;
  540.  
  541. /* The intent behind this definition is that it'll catch
  542.  * any uses of REJECT which flex missed.
  543.  */
  544. #define REJECT reject_used_but_not_detected
  545. #define yymore() yymore_used_but_not_detected
  546. #define YY_MORE_ADJ 0
  547. char *yytext;
  548. #line 1 "l.web2c"
  549. #define INITIAL 0
  550. #line 2 "l.web2c"
  551. /* web2c.lex -- lexical analysis for Tangle output.  */
  552.  
  553. #include "web2c.h"
  554. #ifdef RISCOS
  555. #include "Y_tab.h"
  556. #else
  557. #include "y.tab.h"
  558. #endif
  559.  
  560. /* For some reason flex wants to do a system call, so we must lose the
  561.    definition of the Pascal read that is in `pascal.h'.  */
  562. #undef read
  563.  
  564. char conditional[20], negbuf[2], temp[20];
  565. extern boolean doing_statements;
  566. #define YY_NEVER_INTERACTIVE 1
  567. #line 568 "c.lexyy"
  568.  
  569. /* Macros after this point can all be overridden by user definitions in
  570.  * section 1.
  571.  */
  572.  
  573. #ifndef YY_SKIP_YYWRAP
  574. #ifdef __cplusplus
  575. extern "C" int yywrap YY_PROTO(( void ));
  576. #else
  577. extern int yywrap YY_PROTO(( void ));
  578. #endif
  579. #endif
  580.  
  581. #ifndef YY_NO_UNPUT
  582. static void yyunput YY_PROTO(( int c, char *buf_ptr ));
  583. #endif
  584.  
  585. #ifndef yytext_ptr
  586. static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
  587. #endif
  588.  
  589. #ifndef YY_NO_INPUT
  590. #ifdef __cplusplus
  591. static int yyinput YY_PROTO(( void ));
  592. #else
  593. static int input YY_PROTO(( void ));
  594. #endif
  595. #endif
  596.  
  597. #if YY_STACK_USED
  598. static int yy_start_stack_ptr = 0;
  599. static int yy_start_stack_depth = 0;
  600. static int *yy_start_stack = 0;
  601. #ifndef YY_NO_PUSH_STATE
  602. static void yy_push_state YY_PROTO(( int new_state ));
  603. #endif
  604. #ifndef YY_NO_POP_STATE
  605. static void yy_pop_state YY_PROTO(( void ));
  606. #endif
  607. #ifndef YY_NO_TOP_STATE
  608. static int yy_top_state YY_PROTO(( void ));
  609. #endif
  610.  
  611. #else
  612. #define YY_NO_PUSH_STATE 1
  613. #define YY_NO_POP_STATE 1
  614. #define YY_NO_TOP_STATE 1
  615. #endif
  616.  
  617. #ifdef YY_MALLOC_DECL
  618. YY_MALLOC_DECL
  619. #else
  620. #if __STDC__
  621. #ifndef __cplusplus
  622. #include <stdlib.h>
  623. #endif
  624. #else
  625. /* Just try to get by without declaring the routines.  This will fail
  626.  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
  627.  * or sizeof(void*) != sizeof(int).
  628.  */
  629. #endif
  630. #endif
  631.  
  632. /* Amount of stuff to slurp up with each read. */
  633. #ifndef YY_READ_BUF_SIZE
  634. #define YY_READ_BUF_SIZE 8192
  635. #endif
  636.  
  637. /* Copy whatever the last rule matched to the standard output. */
  638.  
  639. #ifndef ECHO
  640. /* This used to be an fputs(), but since the string might contain NUL's,
  641.  * we now use fwrite().
  642.  */
  643. #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
  644. #endif
  645.  
  646. /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
  647.  * is returned in "result".
  648.  */
  649. #ifndef YY_INPUT
  650. #define YY_INPUT(buf,result,max_size) \
  651.     if ( yy_current_buffer->yy_is_interactive ) \
  652.         { \
  653.         int c = '*', n; \
  654.         for ( n = 0; n < max_size && \
  655.                  (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
  656.             buf[n] = (char) c; \
  657.         if ( c == '\n' ) \
  658.             buf[n++] = (char) c; \
  659.         if ( c == EOF && ferror( yyin ) ) \
  660.             YY_FATAL_ERROR( "input in flex scanner failed" ); \
  661.         result = n; \
  662.         } \
  663.     else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
  664.           && ferror( yyin ) ) \
  665.         YY_FATAL_ERROR( "input in flex scanner failed" );
  666. #endif
  667.  
  668. /* No semi-colon after return; correct usage is to write "yyterminate();" -
  669.  * we don't want an extra ';' after the "return" because that will cause
  670.  * some compilers to complain about unreachable statements.
  671.  */
  672. #ifndef yyterminate
  673. #define yyterminate() return YY_NULL
  674. #endif
  675.  
  676. /* Number of entries by which start-condition stack grows. */
  677. #ifndef YY_START_STACK_INCR
  678. #define YY_START_STACK_INCR 25
  679. #endif
  680.  
  681. /* Report a fatal error. */
  682. #ifndef YY_FATAL_ERROR
  683. #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
  684. #endif
  685.  
  686. /* Default declaration of generated scanner - a define so the user can
  687.  * easily add parameters.
  688.  */
  689. #ifndef YY_DECL
  690. #define YY_DECL int yylex YY_PROTO(( void ))
  691. #endif
  692.  
  693. /* Code executed at the beginning of each rule, after yytext and yyleng
  694.  * have been set up.
  695.  */
  696. #ifndef YY_USER_ACTION
  697. #define YY_USER_ACTION
  698. #endif
  699.  
  700. /* Code executed at the end of each rule. */
  701. #ifndef YY_BREAK
  702. #define YY_BREAK break;
  703. #endif
  704.  
  705. #define YY_RULE_SETUP \
  706.     YY_USER_ACTION
  707.  
  708. YY_DECL
  709.     {
  710.     register yy_state_type yy_current_state;
  711.     register char *yy_cp, *yy_bp;
  712.     register int yy_act;
  713.  
  714. #line 34 "l.web2c"
  715.  
  716. #line 717 "c.lexyy"
  717.  
  718.     if ( yy_init )
  719.         {
  720.         yy_init = 0;
  721.  
  722. #ifdef YY_USER_INIT
  723.         YY_USER_INIT;
  724. #endif
  725.  
  726.         if ( ! yy_start )
  727.             yy_start = 1;    /* first start state */
  728.  
  729.         if ( ! yyin )
  730.             yyin = stdin;
  731.  
  732.         if ( ! yyout )
  733.             yyout = stdout;
  734.  
  735.         if ( ! yy_current_buffer )
  736.             yy_current_buffer =
  737.                 yy_create_buffer( yyin, YY_BUF_SIZE );
  738.  
  739.         yy_load_buffer_state();
  740.         }
  741.  
  742.     while ( 1 )        /* loops until end-of-file is reached */
  743.         {
  744.         yy_cp = yy_c_buf_p;
  745.  
  746.         /* Support of yytext. */
  747.         *yy_cp = yy_hold_char;
  748.  
  749.         /* yy_bp points to the position in yy_ch_buf of the start of
  750.          * the current run.
  751.          */
  752.         yy_bp = yy_cp;
  753.  
  754.         yy_current_state = yy_start;
  755. yy_match:
  756.         do
  757.             {
  758.             register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
  759.             if ( yy_accept[yy_current_state] )
  760.                 {
  761.                 yy_last_accepting_state = yy_current_state;
  762.                 yy_last_accepting_cpos = yy_cp;
  763.                 }
  764.             while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  765.                 {
  766.                 yy_current_state = (int) yy_def[yy_current_state];
  767.                 if ( yy_current_state >= 265 )
  768.                     yy_c = yy_meta[(unsigned int) yy_c];
  769.                 }
  770.             yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
  771.             ++yy_cp;
  772.             }
  773.         while ( yy_current_state != 264 );
  774.         yy_cp = yy_last_accepting_cpos;
  775.         yy_current_state = yy_last_accepting_state;
  776.  
  777. yy_find_action:
  778.         yy_act = yy_accept[yy_current_state];
  779.  
  780.         YY_DO_BEFORE_ACTION;
  781.  
  782.  
  783. do_action:    /* This label is used only to access EOF actions. */
  784.  
  785.  
  786.         switch ( yy_act )
  787.     { /* beginning of action switch */
  788.             case 0: /* must back up */
  789.             /* undo the effects of YY_DO_BEFORE_ACTION */
  790.             *yy_cp = yy_hold_char;
  791.             yy_cp = yy_last_accepting_cpos;
  792.             yy_current_state = yy_last_accepting_state;
  793.             goto yy_find_action;
  794.  
  795. case 1:
  796. YY_RULE_SETUP
  797. #line 35 "l.web2c"
  798. ;
  799.     YY_BREAK
  800. case 2:
  801. YY_RULE_SETUP
  802. #line 36 "l.web2c"
  803. {while (input() != '}') ;}
  804.     YY_BREAK
  805. case 3:
  806. YY_RULE_SETUP
  807. #line 38 "l.web2c"
  808. {
  809.             register int c;
  810.             (void) putc('#', std);
  811.             while ((c = input()) && c != ';')
  812.             (void) putc(c, std);
  813.             (void) putc('\n', std);
  814.         }
  815.     YY_BREAK
  816. case 4:
  817. YY_RULE_SETUP
  818. #line 46 "l.web2c"
  819. {register int c;
  820.          extern char my_routine[];
  821.          register char *cp=conditional;
  822.          new_line();
  823.          (void) input();
  824.          while ((c = input()) != '\'')
  825.             *cp++ = c;
  826.          *cp = '\0';
  827.          (void) input();
  828.          if (doing_statements) fputs("\t;\n", std);
  829.          (void) fprintf(std,
  830.             "#ifdef %s\n", conditional);
  831.         }
  832.     YY_BREAK
  833. case 5:
  834. YY_RULE_SETUP
  835. #line 60 "l.web2c"
  836. {register int c;
  837.          new_line();
  838.          fputs("#endif /* ", std);
  839.          (void) input();
  840.          while ((c = input()) != '\'')
  841.             (void) putc(c, std);
  842.          (void) input();
  843.          conditional[0] = '\0';
  844.          fputs(" */\n", std);
  845.         }
  846.     YY_BREAK
  847. case 6:
  848. YY_RULE_SETUP
  849. #line 71 "l.web2c"
  850. ;
  851.     YY_BREAK
  852. case 7:
  853. YY_RULE_SETUP
  854. #line 73 "l.web2c"
  855. ;
  856.     YY_BREAK
  857. case 8:
  858. YY_RULE_SETUP
  859. #line 75 "l.web2c"
  860. return last_tok=define_tok;
  861.     YY_BREAK
  862. case 9:
  863. YY_RULE_SETUP
  864. #line 76 "l.web2c"
  865. return last_tok=field_tok;
  866.     YY_BREAK
  867. case 10:
  868. YY_RULE_SETUP
  869. #line 77 "l.web2c"
  870. return last_tok=and_tok;
  871.     YY_BREAK
  872. case 11:
  873. YY_RULE_SETUP
  874. #line 78 "l.web2c"
  875. return last_tok=array_tok;
  876.     YY_BREAK
  877. case 12:
  878. YY_RULE_SETUP
  879. #line 79 "l.web2c"
  880. return last_tok=begin_tok;
  881.     YY_BREAK
  882. case 13:
  883. YY_RULE_SETUP
  884. #line 80 "l.web2c"
  885. return last_tok=case_tok;
  886.     YY_BREAK
  887. case 14:
  888. YY_RULE_SETUP
  889. #line 81 "l.web2c"
  890. return last_tok=const_tok;
  891.     YY_BREAK
  892. case 15:
  893. YY_RULE_SETUP
  894. #line 82 "l.web2c"
  895. return last_tok=div_tok;
  896.     YY_BREAK
  897. case 16:
  898. YY_RULE_SETUP
  899. #line 83 "l.web2c"
  900. return last_tok=break_tok;
  901.     YY_BREAK
  902. case 17:
  903. YY_RULE_SETUP
  904. #line 84 "l.web2c"
  905. return last_tok=do_tok;
  906.     YY_BREAK
  907. case 18:
  908. YY_RULE_SETUP
  909. #line 85 "l.web2c"
  910. return last_tok=downto_tok;
  911.     YY_BREAK
  912. case 19:
  913. YY_RULE_SETUP
  914. #line 86 "l.web2c"
  915. return last_tok=else_tok;
  916.     YY_BREAK
  917. case 20:
  918. YY_RULE_SETUP
  919. #line 87 "l.web2c"
  920. return last_tok=end_tok;
  921.     YY_BREAK
  922. case 21:
  923. YY_RULE_SETUP
  924. #line 88 "l.web2c"
  925. return last_tok=file_tok;
  926.     YY_BREAK
  927. case 22:
  928. YY_RULE_SETUP
  929. #line 89 "l.web2c"
  930. return last_tok=for_tok;
  931.     YY_BREAK
  932. case 23:
  933. YY_RULE_SETUP
  934. #line 90 "l.web2c"
  935. return last_tok=function_tok;
  936.     YY_BREAK
  937. case 24:
  938. YY_RULE_SETUP
  939. #line 91 "l.web2c"
  940. return last_tok=goto_tok;
  941.     YY_BREAK
  942. case 25:
  943. YY_RULE_SETUP
  944. #line 92 "l.web2c"
  945. return last_tok=if_tok;
  946.     YY_BREAK
  947. case 26:
  948. YY_RULE_SETUP
  949. #line 93 "l.web2c"
  950. return last_tok=label_tok;
  951.     YY_BREAK
  952. case 27:
  953. YY_RULE_SETUP
  954. #line 94 "l.web2c"
  955. return last_tok=mod_tok;
  956.     YY_BREAK
  957. case 28:
  958. YY_RULE_SETUP
  959. #line 95 "l.web2c"
  960. return last_tok=not_tok;
  961.     YY_BREAK
  962. case 29:
  963. YY_RULE_SETUP
  964. #line 96 "l.web2c"
  965. return last_tok=of_tok;
  966.     YY_BREAK
  967. case 30:
  968. YY_RULE_SETUP
  969. #line 97 "l.web2c"
  970. return last_tok=or_tok;
  971.     YY_BREAK
  972. case 31:
  973. YY_RULE_SETUP
  974. #line 98 "l.web2c"
  975. return last_tok=procedure_tok;
  976.     YY_BREAK
  977. case 32:
  978. YY_RULE_SETUP
  979. #line 99 "l.web2c"
  980. return last_tok=program_tok;
  981.     YY_BREAK
  982. case 33:
  983. YY_RULE_SETUP
  984. #line 100 "l.web2c"
  985. return last_tok=record_tok;
  986.     YY_BREAK
  987. case 34:
  988. YY_RULE_SETUP
  989. #line 101 "l.web2c"
  990. return last_tok=repeat_tok;
  991.     YY_BREAK
  992. case 35:
  993. YY_RULE_SETUP
  994. #line 102 "l.web2c"
  995. return last_tok=hhb0_tok;
  996.     YY_BREAK
  997. case 36:
  998. YY_RULE_SETUP
  999. #line 103 "l.web2c"
  1000. return last_tok=hhb1_tok;
  1001.     YY_BREAK
  1002. case 37:
  1003. YY_RULE_SETUP
  1004. #line 104 "l.web2c"
  1005. return last_tok=then_tok;
  1006.     YY_BREAK
  1007. case 38:
  1008. YY_RULE_SETUP
  1009. #line 105 "l.web2c"
  1010. return last_tok=to_tok;
  1011.     YY_BREAK
  1012. case 39:
  1013. YY_RULE_SETUP
  1014. #line 106 "l.web2c"
  1015. return last_tok=type_tok;
  1016.     YY_BREAK
  1017. case 40:
  1018. YY_RULE_SETUP
  1019. #line 107 "l.web2c"
  1020. return last_tok=until_tok;
  1021.     YY_BREAK
  1022. case 41:
  1023. YY_RULE_SETUP
  1024. #line 108 "l.web2c"
  1025. return last_tok=var_tok;
  1026.     YY_BREAK
  1027. case 42:
  1028. YY_RULE_SETUP
  1029. #line 109 "l.web2c"
  1030. return last_tok=while_tok;
  1031.     YY_BREAK
  1032. case 43:
  1033. YY_RULE_SETUP
  1034. #line 110 "l.web2c"
  1035. return last_tok=others_tok;
  1036.     YY_BREAK
  1037. case 44:
  1038. YY_RULE_SETUP
  1039. #line 112 "l.web2c"
  1040. {        
  1041.           (void) sprintf(temp, "%s%s", negbuf, yytext);
  1042.           negbuf[0] = '\0';
  1043.           return last_tok=r_num_tok;
  1044.         }
  1045.     YY_BREAK
  1046. case 45:
  1047. YY_RULE_SETUP
  1048. #line 118 "l.web2c"
  1049. {
  1050.           (void) sprintf(temp, "%s%s", negbuf, yytext);
  1051.           negbuf[0] = '\0';
  1052.           return last_tok=i_num_tok;
  1053.         }
  1054.     YY_BREAK
  1055. case 46:
  1056. YY_RULE_SETUP
  1057. #line 124 "l.web2c"
  1058. return last_tok=single_char_tok;
  1059.     YY_BREAK
  1060. case 47:
  1061. YY_RULE_SETUP
  1062. #line 126 "l.web2c"
  1063. return last_tok=string_literal_tok;
  1064.     YY_BREAK
  1065. case 48:
  1066. YY_RULE_SETUP
  1067. #line 128 "l.web2c"
  1068. { if ((last_tok>=undef_id_tok &&
  1069.               last_tok<=field_id_tok) ||
  1070.               last_tok==i_num_tok ||
  1071.               last_tok==r_num_tok ||
  1072.               last_tok==')' ||
  1073.               last_tok==']')
  1074.            return last_tok='+';
  1075.         else return last_tok=unary_plus_tok; }
  1076.     YY_BREAK
  1077. case 49:
  1078. YY_RULE_SETUP
  1079. #line 137 "l.web2c"
  1080. { if ((last_tok>=undef_id_tok &&
  1081.               last_tok<=field_id_tok) ||
  1082.               last_tok==i_num_tok ||
  1083.               last_tok==r_num_tok ||
  1084.               last_tok==')' ||
  1085.               last_tok==']')
  1086.            return last_tok='-';
  1087.         else {
  1088.           int c;
  1089.           while ((c = input()) == ' ' || c == '\t')
  1090.                     ;
  1091.             unput(c);
  1092.           if (c < '0' || c > '9') {
  1093.             return last_tok = unary_minus_tok;
  1094.           }
  1095.           negbuf[0] = '-';
  1096.         }}
  1097.     YY_BREAK
  1098. case 50:
  1099. YY_RULE_SETUP
  1100. #line 155 "l.web2c"
  1101. return last_tok='*';
  1102.     YY_BREAK
  1103. case 51:
  1104. YY_RULE_SETUP
  1105. #line 156 "l.web2c"
  1106. return last_tok='/';
  1107.     YY_BREAK
  1108. case 52:
  1109. YY_RULE_SETUP
  1110. #line 157 "l.web2c"
  1111. return last_tok='=';
  1112.     YY_BREAK
  1113. case 53:
  1114. YY_RULE_SETUP
  1115. #line 158 "l.web2c"
  1116. return last_tok=not_eq_tok;
  1117.     YY_BREAK
  1118. case 54:
  1119. YY_RULE_SETUP
  1120. #line 159 "l.web2c"
  1121. return last_tok='<';
  1122.     YY_BREAK
  1123. case 55:
  1124. YY_RULE_SETUP
  1125. #line 160 "l.web2c"
  1126. return last_tok='>';
  1127.     YY_BREAK
  1128. case 56:
  1129. YY_RULE_SETUP
  1130. #line 161 "l.web2c"
  1131. return last_tok=less_eq_tok;
  1132.     YY_BREAK
  1133. case 57:
  1134. YY_RULE_SETUP
  1135. #line 162 "l.web2c"
  1136. return last_tok=great_eq_tok;
  1137.     YY_BREAK
  1138. case 58:
  1139. YY_RULE_SETUP
  1140. #line 163 "l.web2c"
  1141. return last_tok='(';
  1142.     YY_BREAK
  1143. case 59:
  1144. YY_RULE_SETUP
  1145. #line 164 "l.web2c"
  1146. return last_tok=')';
  1147.     YY_BREAK
  1148. case 60:
  1149. YY_RULE_SETUP
  1150. #line 165 "l.web2c"
  1151. return last_tok='[';
  1152.     YY_BREAK
  1153. case 61:
  1154. YY_RULE_SETUP
  1155. #line 166 "l.web2c"
  1156. return last_tok=']';
  1157.     YY_BREAK
  1158. case 62:
  1159. YY_RULE_SETUP
  1160. #line 167 "l.web2c"
  1161. return last_tok=assign_tok;
  1162.     YY_BREAK
  1163. case 63:
  1164. YY_RULE_SETUP
  1165. #line 168 "l.web2c"
  1166. return last_tok=two_dots_tok;
  1167.     YY_BREAK
  1168. case 64:
  1169. YY_RULE_SETUP
  1170. #line 169 "l.web2c"
  1171. return last_tok='.';
  1172.     YY_BREAK
  1173. case 65:
  1174. YY_RULE_SETUP
  1175. #line 170 "l.web2c"
  1176. return last_tok=',';
  1177.     YY_BREAK
  1178. case 66:
  1179. YY_RULE_SETUP
  1180. #line 171 "l.web2c"
  1181. return last_tok=';';
  1182.     YY_BREAK
  1183. case 67:
  1184. YY_RULE_SETUP
  1185. #line 172 "l.web2c"
  1186. return last_tok=':';
  1187.     YY_BREAK
  1188. case 68:
  1189. YY_RULE_SETUP
  1190. #line 173 "l.web2c"
  1191. return last_tok='^';
  1192.     YY_BREAK
  1193. case 69:
  1194. YY_RULE_SETUP
  1195. #line 175 "l.web2c"
  1196. { (void) strcpy (last_id, yytext);
  1197.           l_s = search_table (last_id);
  1198.           return
  1199.                     last_tok = (l_s == -1 ? undef_id_tok : sym_table[l_s].typ);
  1200.         }
  1201.     YY_BREAK
  1202. case 70:
  1203. YY_RULE_SETUP
  1204. #line 182 "l.web2c"
  1205. { /* Any bizarre token will do.  */
  1206.           return last_tok = two_dots_tok; }
  1207.     YY_BREAK
  1208. case 71:
  1209. YY_RULE_SETUP
  1210. #line 184 "l.web2c"
  1211. ECHO;
  1212.     YY_BREAK
  1213. #line 1214 "c.lexyy"
  1214. case YY_STATE_EOF(INITIAL):
  1215.     yyterminate();
  1216.  
  1217.     case YY_END_OF_BUFFER:
  1218.         {
  1219.         /* Amount of text matched not including the EOB char. */
  1220.         int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
  1221.  
  1222.         /* Undo the effects of YY_DO_BEFORE_ACTION. */
  1223.         *yy_cp = yy_hold_char;
  1224.  
  1225.         if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
  1226.             {
  1227.             /* We're scanning a new file or input source.  It's
  1228.              * possible that this happened because the user
  1229.              * just pointed yyin at a new source and called
  1230.              * yylex().  If so, then we have to assure
  1231.              * consistency between yy_current_buffer and our
  1232.              * globals.  Here is the right place to do so, because
  1233.              * this is the first action (other than possibly a
  1234.              * back-up) that will match for the new input source.
  1235.              */
  1236.             yy_n_chars = yy_current_buffer->yy_n_chars;
  1237.             yy_current_buffer->yy_input_file = yyin;
  1238.             yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
  1239.             }
  1240.  
  1241.         /* Note that here we test for yy_c_buf_p "<=" to the position
  1242.          * of the first EOB in the buffer, since yy_c_buf_p will
  1243.          * already have been incremented past the NUL character
  1244.          * (since all states make transitions on EOB to the
  1245.          * end-of-buffer state).  Contrast this with the test
  1246.          * in input().
  1247.          */
  1248.         if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
  1249.             { /* This was really a NUL. */
  1250.             yy_state_type yy_next_state;
  1251.  
  1252.             yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
  1253.  
  1254.             yy_current_state = yy_get_previous_state();
  1255.  
  1256.             /* Okay, we're now positioned to make the NUL
  1257.              * transition.  We couldn't have
  1258.              * yy_get_previous_state() go ahead and do it
  1259.              * for us because it doesn't know how to deal
  1260.              * with the possibility of jamming (and we don't
  1261.              * want to build jamming into it because then it
  1262.              * will run more slowly).
  1263.              */
  1264.  
  1265.             yy_next_state = yy_try_NUL_trans( yy_current_state );
  1266.  
  1267.             yy_bp = yytext_ptr + YY_MORE_ADJ;
  1268.  
  1269.             if ( yy_next_state )
  1270.                 {
  1271.                 /* Consume the NUL. */
  1272.                 yy_cp = ++yy_c_buf_p;
  1273.                 yy_current_state = yy_next_state;
  1274.                 goto yy_match;
  1275.                 }
  1276.  
  1277.             else
  1278.                 {
  1279.                 yy_cp = yy_last_accepting_cpos;
  1280.                 yy_current_state = yy_last_accepting_state;
  1281.                 goto yy_find_action;
  1282.                 }
  1283.             }
  1284.  
  1285.         else switch ( yy_get_next_buffer() )
  1286.             {
  1287.             case EOB_ACT_END_OF_FILE:
  1288.                 {
  1289.                 yy_did_buffer_switch_on_eof = 0;
  1290.  
  1291.                 if ( yywrap() )
  1292.                     {
  1293.                     /* Note: because we've taken care in
  1294.                      * yy_get_next_buffer() to have set up
  1295.                      * yytext, we can now set up
  1296.                      * yy_c_buf_p so that if some total
  1297.                      * hoser (like flex itself) wants to
  1298.                      * call the scanner after we return the
  1299.                      * YY_NULL, it'll still work - another
  1300.                      * YY_NULL will get returned.
  1301.                      */
  1302.                     yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
  1303.  
  1304.                     yy_act = YY_STATE_EOF(YY_START);
  1305.                     goto do_action;
  1306.                     }
  1307.  
  1308.                 else
  1309.                     {
  1310.                     if ( ! yy_did_buffer_switch_on_eof )
  1311.                         YY_NEW_FILE;
  1312.                     }
  1313.                 break;
  1314.                 }
  1315.  
  1316.             case EOB_ACT_CONTINUE_SCAN:
  1317.                 yy_c_buf_p =
  1318.                     yytext_ptr + yy_amount_of_matched_text;
  1319.  
  1320.                 yy_current_state = yy_get_previous_state();
  1321.  
  1322.                 yy_cp = yy_c_buf_p;
  1323.                 yy_bp = yytext_ptr + YY_MORE_ADJ;
  1324.                 goto yy_match;
  1325.  
  1326.             case EOB_ACT_LAST_MATCH:
  1327.                 yy_c_buf_p =
  1328.                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
  1329.  
  1330.                 yy_current_state = yy_get_previous_state();
  1331.  
  1332.                 yy_cp = yy_c_buf_p;
  1333.                 yy_bp = yytext_ptr + YY_MORE_ADJ;
  1334.                 goto yy_find_action;
  1335.             }
  1336.         break;
  1337.         }
  1338.  
  1339.     default:
  1340.         YY_FATAL_ERROR(
  1341.             "fatal flex scanner internal error--no action found" );
  1342.     } /* end of action switch */
  1343.         } /* end of scanning one token */
  1344.     } /* end of yylex */
  1345.  
  1346.  
  1347. /* yy_get_next_buffer - try to read in a new buffer
  1348.  *
  1349.  * Returns a code representing an action:
  1350.  *    EOB_ACT_LAST_MATCH -
  1351.  *    EOB_ACT_CONTINUE_SCAN - continue scanning from current position
  1352.  *    EOB_ACT_END_OF_FILE - end of file
  1353.  */
  1354.  
  1355. static int yy_get_next_buffer()
  1356.     {
  1357.     register char *dest = yy_current_buffer->yy_ch_buf;
  1358.     register char *source = yytext_ptr;
  1359.     register int number_to_move, i;
  1360.     int ret_val;
  1361.  
  1362.     if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
  1363.         YY_FATAL_ERROR(
  1364.         "fatal flex scanner internal error--end of buffer missed" );
  1365.  
  1366.     if ( yy_current_buffer->yy_fill_buffer == 0 )
  1367.         { /* Don't try to fill the buffer, so this is an EOF. */
  1368.         if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
  1369.             {
  1370.             /* We matched a singled characater, the EOB, so
  1371.              * treat this as a final EOF.
  1372.              */
  1373.             return EOB_ACT_END_OF_FILE;
  1374.             }
  1375.  
  1376.         else
  1377.             {
  1378.             /* We matched some text prior to the EOB, first
  1379.              * process it.
  1380.              */
  1381.             return EOB_ACT_LAST_MATCH;
  1382.             }
  1383.         }
  1384.  
  1385.     /* Try to read more data. */
  1386.  
  1387.     /* First move last chars to start of buffer. */
  1388.     number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
  1389.  
  1390.     for ( i = 0; i < number_to_move; ++i )
  1391.         *(dest++) = *(source++);
  1392.  
  1393.     if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
  1394.         /* don't do the read, it's not guaranteed to return an EOF,
  1395.          * just force an EOF
  1396.          */
  1397.         yy_n_chars = 0;
  1398.  
  1399.     else
  1400.         {
  1401.         int num_to_read =
  1402.             yy_current_buffer->yy_buf_size - number_to_move - 1;
  1403.  
  1404.         while ( num_to_read <= 0 )
  1405.             { /* Not enough room in the buffer - grow it. */
  1406. #ifdef YY_USES_REJECT
  1407.             YY_FATAL_ERROR(
  1408. "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
  1409. #else
  1410.  
  1411.             /* just a shorter name for the current buffer */
  1412.             YY_BUFFER_STATE b = yy_current_buffer;
  1413.  
  1414.             int yy_c_buf_p_offset =
  1415.                 (int) (yy_c_buf_p - b->yy_ch_buf);
  1416.  
  1417.             if ( b->yy_is_our_buffer )
  1418.                 {
  1419.                 int new_size = b->yy_buf_size * 2;
  1420.  
  1421.                 if ( new_size <= 0 )
  1422.                     b->yy_buf_size += b->yy_buf_size / 8;
  1423.                 else
  1424.                     b->yy_buf_size *= 2;
  1425.  
  1426.                 b->yy_ch_buf = (char *)
  1427.                     /* Include room in for 2 EOB chars. */
  1428.                     yy_flex_realloc( (void *) b->yy_ch_buf,
  1429.                              b->yy_buf_size + 2 );
  1430.                 }
  1431.             else
  1432.                 /* Can't grow it, we don't own it. */
  1433.                 b->yy_ch_buf = 0;
  1434.  
  1435.             if ( ! b->yy_ch_buf )
  1436.                 YY_FATAL_ERROR(
  1437.                 "fatal error - scanner input buffer overflow" );
  1438.  
  1439.             yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
  1440.  
  1441.             num_to_read = yy_current_buffer->yy_buf_size -
  1442.                         number_to_move - 1;
  1443. #endif
  1444.             }
  1445.  
  1446.         if ( num_to_read > YY_READ_BUF_SIZE )
  1447.             num_to_read = YY_READ_BUF_SIZE;
  1448.  
  1449.         /* Read in more data. */
  1450.         YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
  1451.             yy_n_chars, num_to_read );
  1452.         }
  1453.  
  1454.     if ( yy_n_chars == 0 )
  1455.         {
  1456.         if ( number_to_move == YY_MORE_ADJ )
  1457.             {
  1458.             ret_val = EOB_ACT_END_OF_FILE;
  1459.             yyrestart( yyin );
  1460.             }
  1461.  
  1462.         else
  1463.             {
  1464.             ret_val = EOB_ACT_LAST_MATCH;
  1465.             yy_current_buffer->yy_buffer_status =
  1466.                 YY_BUFFER_EOF_PENDING;
  1467.             }
  1468.         }
  1469.  
  1470.     else
  1471.         ret_val = EOB_ACT_CONTINUE_SCAN;
  1472.  
  1473.     yy_n_chars += number_to_move;
  1474.     yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
  1475.     yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
  1476.  
  1477.     yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
  1478.  
  1479.     return ret_val;
  1480.     }
  1481.  
  1482.  
  1483. /* yy_get_previous_state - get the state just before the EOB char was reached */
  1484.  
  1485. static yy_state_type yy_get_previous_state()
  1486.     {
  1487.     register yy_state_type yy_current_state;
  1488.     register char *yy_cp;
  1489.  
  1490.     yy_current_state = yy_start;
  1491.  
  1492.     for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
  1493.         {
  1494.         register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
  1495.         if ( yy_accept[yy_current_state] )
  1496.             {
  1497.             yy_last_accepting_state = yy_current_state;
  1498.             yy_last_accepting_cpos = yy_cp;
  1499.             }
  1500.         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  1501.             {
  1502.             yy_current_state = (int) yy_def[yy_current_state];
  1503.             if ( yy_current_state >= 265 )
  1504.                 yy_c = yy_meta[(unsigned int) yy_c];
  1505.             }
  1506.         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
  1507.         }
  1508.  
  1509.     return yy_current_state;
  1510.     }
  1511.  
  1512.  
  1513. /* yy_try_NUL_trans - try to make a transition on the NUL character
  1514.  *
  1515.  * synopsis
  1516.  *    next_state = yy_try_NUL_trans( current_state );
  1517.  */
  1518.  
  1519. #ifdef YY_USE_PROTOS
  1520. static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
  1521. #else
  1522. static yy_state_type yy_try_NUL_trans( yy_current_state )
  1523. yy_state_type yy_current_state;
  1524. #endif
  1525.     {
  1526.     register int yy_is_jam;
  1527.     register char *yy_cp = yy_c_buf_p;
  1528.  
  1529.     register YY_CHAR yy_c = 1;
  1530.     if ( yy_accept[yy_current_state] )
  1531.         {
  1532.         yy_last_accepting_state = yy_current_state;
  1533.         yy_last_accepting_cpos = yy_cp;
  1534.         }
  1535.     while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  1536.         {
  1537.         yy_current_state = (int) yy_def[yy_current_state];
  1538.         if ( yy_current_state >= 265 )
  1539.             yy_c = yy_meta[(unsigned int) yy_c];
  1540.         }
  1541.     yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
  1542.     yy_is_jam = (yy_current_state == 264);
  1543.  
  1544.     return yy_is_jam ? 0 : yy_current_state;
  1545.     }
  1546.  
  1547.  
  1548. #ifndef YY_NO_UNPUT
  1549. #ifdef YY_USE_PROTOS
  1550. static void yyunput( int c, register char *yy_bp )
  1551. #else
  1552. static void yyunput( c, yy_bp )
  1553. int c;
  1554. register char *yy_bp;
  1555. #endif
  1556.     {
  1557.     register char *yy_cp = yy_c_buf_p;
  1558.  
  1559.     /* undo effects of setting up yytext */
  1560.     *yy_cp = yy_hold_char;
  1561.  
  1562.     if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
  1563.         { /* need to shift things up to make room */
  1564.         /* +2 for EOB chars. */
  1565.         register int number_to_move = yy_n_chars + 2;
  1566.         register char *dest = &yy_current_buffer->yy_ch_buf[
  1567.                     yy_current_buffer->yy_buf_size + 2];
  1568.         register char *source =
  1569.                 &yy_current_buffer->yy_ch_buf[number_to_move];
  1570.  
  1571.         while ( source > yy_current_buffer->yy_ch_buf )
  1572.             *--dest = *--source;
  1573.  
  1574.         yy_cp += (int) (dest - source);
  1575.         yy_bp += (int) (dest - source);
  1576.         yy_n_chars = yy_current_buffer->yy_buf_size;
  1577.  
  1578.         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
  1579.             YY_FATAL_ERROR( "flex scanner push-back overflow" );
  1580.         }
  1581.  
  1582.     *--yy_cp = (char) c;
  1583.  
  1584.  
  1585.     yytext_ptr = yy_bp;
  1586.     yy_hold_char = *yy_cp;
  1587.     yy_c_buf_p = yy_cp;
  1588.     }
  1589. #endif    /* ifndef YY_NO_UNPUT */
  1590.  
  1591.  
  1592. #ifdef __cplusplus
  1593. static int yyinput()
  1594. #else
  1595. static int input()
  1596. #endif
  1597.     {
  1598.     int c;
  1599.  
  1600.     *yy_c_buf_p = yy_hold_char;
  1601.  
  1602.     if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
  1603.         {
  1604.         /* yy_c_buf_p now points to the character we want to return.
  1605.          * If this occurs *before* the EOB characters, then it's a
  1606.          * valid NUL; if not, then we've hit the end of the buffer.
  1607.          */
  1608.         if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
  1609.             /* This was really a NUL. */
  1610.             *yy_c_buf_p = '\0';
  1611.  
  1612.         else
  1613.             { /* need more input */
  1614.             yytext_ptr = yy_c_buf_p;
  1615.             ++yy_c_buf_p;
  1616.  
  1617.             switch ( yy_get_next_buffer() )
  1618.                 {
  1619.                 case EOB_ACT_END_OF_FILE:
  1620.                     {
  1621.                     if ( yywrap() )
  1622.                         {
  1623.                         yy_c_buf_p =
  1624.                         yytext_ptr + YY_MORE_ADJ;
  1625.                         return EOF;
  1626.                         }
  1627.  
  1628.                     if ( ! yy_did_buffer_switch_on_eof )
  1629.                         YY_NEW_FILE;
  1630. #ifdef __cplusplus
  1631.                     return yyinput();
  1632. #else
  1633.                     return input();
  1634. #endif
  1635.                     }
  1636.  
  1637.                 case EOB_ACT_CONTINUE_SCAN:
  1638.                     yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
  1639.                     break;
  1640.  
  1641.                 case EOB_ACT_LAST_MATCH:
  1642. #ifdef __cplusplus
  1643.                     YY_FATAL_ERROR(
  1644.                     "unexpected last match in yyinput()" );
  1645. #else
  1646.                     YY_FATAL_ERROR(
  1647.                     "unexpected last match in input()" );
  1648. #endif
  1649.                 }
  1650.             }
  1651.         }
  1652.  
  1653.     c = *(unsigned char *) yy_c_buf_p;    /* cast for 8-bit char's */
  1654.     *yy_c_buf_p = '\0';    /* preserve yytext */
  1655.     yy_hold_char = *++yy_c_buf_p;
  1656.  
  1657.  
  1658.     return c;
  1659.     }
  1660.  
  1661.  
  1662. #ifdef YY_USE_PROTOS
  1663. void yyrestart( FILE *input_file )
  1664. #else
  1665. void yyrestart( input_file )
  1666. FILE *input_file;
  1667. #endif
  1668.     {
  1669.     if ( ! yy_current_buffer )
  1670.         yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
  1671.  
  1672.     yy_init_buffer( yy_current_buffer, input_file );
  1673.     yy_load_buffer_state();
  1674.     }
  1675.  
  1676.  
  1677. #ifdef YY_USE_PROTOS
  1678. void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
  1679. #else
  1680. void yy_switch_to_buffer( new_buffer )
  1681. YY_BUFFER_STATE new_buffer;
  1682. #endif
  1683.     {
  1684.     if ( yy_current_buffer == new_buffer )
  1685.         return;
  1686.  
  1687.     if ( yy_current_buffer )
  1688.         {
  1689.         /* Flush out information for old buffer. */
  1690.         *yy_c_buf_p = yy_hold_char;
  1691.         yy_current_buffer->yy_buf_pos = yy_c_buf_p;
  1692.         yy_current_buffer->yy_n_chars = yy_n_chars;
  1693.         }
  1694.  
  1695.     yy_current_buffer = new_buffer;
  1696.     yy_load_buffer_state();
  1697.  
  1698.     /* We don't actually know whether we did this switch during
  1699.      * EOF (yywrap()) processing, but the only time this flag
  1700.      * is looked at is after yywrap() is called, so it's safe
  1701.      * to go ahead and always set it.
  1702.      */
  1703.     yy_did_buffer_switch_on_eof = 1;
  1704.     }
  1705.  
  1706.  
  1707. #ifdef YY_USE_PROTOS
  1708. void yy_load_buffer_state( void )
  1709. #else
  1710. void yy_load_buffer_state()
  1711. #endif
  1712.     {
  1713.     yy_n_chars = yy_current_buffer->yy_n_chars;
  1714.     yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
  1715.     yyin = yy_current_buffer->yy_input_file;
  1716.     yy_hold_char = *yy_c_buf_p;
  1717.     }
  1718.  
  1719.  
  1720. #ifdef YY_USE_PROTOS
  1721. YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
  1722. #else
  1723. YY_BUFFER_STATE yy_create_buffer( file, size )
  1724. FILE *file;
  1725. int size;
  1726. #endif
  1727.     {
  1728.     YY_BUFFER_STATE b;
  1729.  
  1730.     b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
  1731.     if ( ! b )
  1732.         YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
  1733.  
  1734.     b->yy_buf_size = size;
  1735.  
  1736.     /* yy_ch_buf has to be 2 characters longer than the size given because
  1737.      * we need to put in 2 end-of-buffer characters.
  1738.      */
  1739.     b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
  1740.     if ( ! b->yy_ch_buf )
  1741.         YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
  1742.  
  1743.     b->yy_is_our_buffer = 1;
  1744.  
  1745.     yy_init_buffer( b, file );
  1746.  
  1747.     return b;
  1748.     }
  1749.  
  1750.  
  1751. #ifdef YY_USE_PROTOS
  1752. void yy_delete_buffer( YY_BUFFER_STATE b )
  1753. #else
  1754. void yy_delete_buffer( b )
  1755. YY_BUFFER_STATE b;
  1756. #endif
  1757.     {
  1758.     if ( ! b )
  1759.         return;
  1760.  
  1761.     if ( b == yy_current_buffer )
  1762.         yy_current_buffer = (YY_BUFFER_STATE) 0;
  1763.  
  1764.     if ( b->yy_is_our_buffer )
  1765.         yy_flex_free( (void *) b->yy_ch_buf );
  1766.  
  1767.     yy_flex_free( (void *) b );
  1768.     }
  1769.  
  1770.  
  1771. #ifndef YY_ALWAYS_INTERACTIVE
  1772. #ifndef YY_NEVER_INTERACTIVE
  1773. extern int isatty YY_PROTO(( int ));
  1774. #endif
  1775. #endif
  1776.  
  1777. #ifdef YY_USE_PROTOS
  1778. void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
  1779. #else
  1780. void yy_init_buffer( b, file )
  1781. YY_BUFFER_STATE b;
  1782. FILE *file;
  1783. #endif
  1784.  
  1785.  
  1786.     {
  1787.     yy_flush_buffer( b );
  1788.  
  1789.     b->yy_input_file = file;
  1790.     b->yy_fill_buffer = 1;
  1791.  
  1792. #if YY_ALWAYS_INTERACTIVE
  1793.     b->yy_is_interactive = 1;
  1794. #else
  1795. #if YY_NEVER_INTERACTIVE
  1796.     b->yy_is_interactive = 0;
  1797. #else
  1798.     b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
  1799. #endif
  1800. #endif
  1801.     }
  1802.  
  1803.  
  1804. #ifdef YY_USE_PROTOS
  1805. void yy_flush_buffer( YY_BUFFER_STATE b )
  1806. #else
  1807. void yy_flush_buffer( b )
  1808. YY_BUFFER_STATE b;
  1809. #endif
  1810.  
  1811.     {
  1812.     b->yy_n_chars = 0;
  1813.  
  1814.     /* We always need two end-of-buffer characters.  The first causes
  1815.      * a transition to the end-of-buffer state.  The second causes
  1816.      * a jam in that state.
  1817.      */
  1818.     b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
  1819.     b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
  1820.  
  1821.     b->yy_buf_pos = &b->yy_ch_buf[0];
  1822.  
  1823.     b->yy_at_bol = 1;
  1824.     b->yy_buffer_status = YY_BUFFER_NEW;
  1825.  
  1826.     if ( b == yy_current_buffer )
  1827.         yy_load_buffer_state();
  1828.     }
  1829.  
  1830.  
  1831. #ifndef YY_NO_SCAN_BUFFER
  1832. #ifdef YY_USE_PROTOS
  1833. YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
  1834. #else
  1835. YY_BUFFER_STATE yy_scan_buffer( base, size )
  1836. char *base;
  1837. yy_size_t size;
  1838. #endif
  1839.     {
  1840.     YY_BUFFER_STATE b;
  1841.  
  1842.     if ( size < 2 ||
  1843.          base[size-2] != YY_END_OF_BUFFER_CHAR ||
  1844.          base[size-1] != YY_END_OF_BUFFER_CHAR )
  1845.         /* They forgot to leave room for the EOB's. */
  1846.         return 0;
  1847.  
  1848.     b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
  1849.     if ( ! b )
  1850.         YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
  1851.  
  1852.     b->yy_buf_size = size - 2;    /* "- 2" to take care of EOB's */
  1853.     b->yy_buf_pos = b->yy_ch_buf = base;
  1854.     b->yy_is_our_buffer = 0;
  1855.     b->yy_input_file = 0;
  1856.     b->yy_n_chars = b->yy_buf_size;
  1857.     b->yy_is_interactive = 0;
  1858.     b->yy_at_bol = 1;
  1859.     b->yy_fill_buffer = 0;
  1860.     b->yy_buffer_status = YY_BUFFER_NEW;
  1861.  
  1862.     yy_switch_to_buffer( b );
  1863.  
  1864.     return b;
  1865.     }
  1866. #endif
  1867.  
  1868.  
  1869. #ifndef YY_NO_SCAN_STRING
  1870. #ifdef YY_USE_PROTOS
  1871. YY_BUFFER_STATE yy_scan_string( yyconst char *str )
  1872. #else
  1873. YY_BUFFER_STATE yy_scan_string( str )
  1874. yyconst char *str;
  1875. #endif
  1876.     {
  1877.     int len;
  1878.     for ( len = 0; str[len]; ++len )
  1879.         ;
  1880.  
  1881.     return yy_scan_bytes( str, len );
  1882.     }
  1883. #endif
  1884.  
  1885.  
  1886. #ifndef YY_NO_SCAN_BYTES
  1887. #ifdef YY_USE_PROTOS
  1888. YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
  1889. #else
  1890. YY_BUFFER_STATE yy_scan_bytes( bytes, len )
  1891. yyconst char *bytes;
  1892. int len;
  1893. #endif
  1894.     {
  1895.     YY_BUFFER_STATE b;
  1896.     char *buf;
  1897.     yy_size_t n;
  1898.     int i;
  1899.  
  1900.     /* Get memory for full buffer, including space for trailing EOB's. */
  1901.     n = len + 2;
  1902.     buf = (char *) yy_flex_alloc( n );
  1903.     if ( ! buf )
  1904.         YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
  1905.  
  1906.     for ( i = 0; i < len; ++i )
  1907.         buf[i] = bytes[i];
  1908.  
  1909.     buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
  1910.  
  1911.     b = yy_scan_buffer( buf, n );
  1912.     if ( ! b )
  1913.         YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
  1914.  
  1915.     /* It's okay to grow etc. this buffer, and we should throw it
  1916.      * away when we're done.
  1917.      */
  1918.     b->yy_is_our_buffer = 1;
  1919.  
  1920.     return b;
  1921.     }
  1922. #endif
  1923.  
  1924.  
  1925. #ifndef YY_NO_PUSH_STATE
  1926. #ifdef YY_USE_PROTOS
  1927. static void yy_push_state( int new_state )
  1928. #else
  1929. static void yy_push_state( new_state )
  1930. int new_state;
  1931. #endif
  1932.     {
  1933.     if ( yy_start_stack_ptr >= yy_start_stack_depth )
  1934.         {
  1935.         yy_size_t new_size;
  1936.  
  1937.         yy_start_stack_depth += YY_START_STACK_INCR;
  1938.         new_size = yy_start_stack_depth * sizeof( int );
  1939.  
  1940.         if ( ! yy_start_stack )
  1941.             yy_start_stack = (int *) yy_flex_alloc( new_size );
  1942.  
  1943.         else
  1944.             yy_start_stack = (int *) yy_flex_realloc(
  1945.                     (void *) yy_start_stack, new_size );
  1946.  
  1947.         if ( ! yy_start_stack )
  1948.             YY_FATAL_ERROR(
  1949.             "out of memory expanding start-condition stack" );
  1950.         }
  1951.  
  1952.     yy_start_stack[yy_start_stack_ptr++] = YY_START;
  1953.  
  1954.     BEGIN(new_state);
  1955.     }
  1956. #endif
  1957.  
  1958.  
  1959. #ifndef YY_NO_POP_STATE
  1960. static void yy_pop_state()
  1961.     {
  1962.     if ( --yy_start_stack_ptr < 0 )
  1963.         YY_FATAL_ERROR( "start-condition stack underflow" );
  1964.  
  1965.     BEGIN(yy_start_stack[yy_start_stack_ptr]);
  1966.     }
  1967. #endif
  1968.  
  1969.  
  1970. #ifndef YY_NO_TOP_STATE
  1971. static int yy_top_state()
  1972.     {
  1973.     return yy_start_stack[yy_start_stack_ptr - 1];
  1974.     }
  1975. #endif
  1976.  
  1977. #ifndef YY_EXIT_FAILURE
  1978. #define YY_EXIT_FAILURE 2
  1979. #endif
  1980.  
  1981. #ifdef YY_USE_PROTOS
  1982. static void yy_fatal_error( yyconst char msg[] )
  1983. #else
  1984. static void yy_fatal_error( msg )
  1985. char msg[];
  1986. #endif
  1987.     {
  1988.     (void) fprintf( stderr, "%s\n", msg );
  1989.     exit( YY_EXIT_FAILURE );
  1990.     }
  1991.  
  1992.  
  1993.  
  1994. /* Redefine yyless() so it works in section 3 code. */
  1995.  
  1996. #undef yyless
  1997. #define yyless(n) \
  1998.     do \
  1999.         { \
  2000.         /* Undo effects of setting up yytext. */ \
  2001.         yytext[yyleng] = yy_hold_char; \
  2002.         yy_c_buf_p = yytext + n - YY_MORE_ADJ; \
  2003.         yy_hold_char = *yy_c_buf_p; \
  2004.         *yy_c_buf_p = '\0'; \
  2005.         yyleng = n; \
  2006.         } \
  2007.     while ( 0 )
  2008.  
  2009.  
  2010. /* Internal utility routines. */
  2011.  
  2012. #ifndef yytext_ptr
  2013. #ifdef YY_USE_PROTOS
  2014. static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
  2015. #else
  2016. static void yy_flex_strncpy( s1, s2, n )
  2017. char *s1;
  2018. yyconst char *s2;
  2019. int n;
  2020. #endif
  2021.     {
  2022.     register int i;
  2023.     for ( i = 0; i < n; ++i )
  2024.         s1[i] = s2[i];
  2025.     }
  2026. #endif
  2027.  
  2028.  
  2029. #ifdef YY_USE_PROTOS
  2030. static void *yy_flex_alloc( yy_size_t size )
  2031. #else
  2032. static void *yy_flex_alloc( size )
  2033. yy_size_t size;
  2034. #endif
  2035.     {
  2036.     return (void *) malloc( size );
  2037.     }
  2038.  
  2039. #ifdef YY_USE_PROTOS
  2040. static void *yy_flex_realloc( void *ptr, yy_size_t size )
  2041. #else
  2042. static void *yy_flex_realloc( ptr, size )
  2043. void *ptr;
  2044. yy_size_t size;
  2045. #endif
  2046.     {
  2047.     /* The cast to (char *) in the following accommodates both
  2048.      * implementations that use char* generic pointers, and those
  2049.      * that use void* generic pointers.  It works with the latter
  2050.      * because both ANSI C and C++ allow castless assignment from
  2051.      * any pointer type to void*, and deal with argument conversions
  2052.      * as though doing an assignment.
  2053.      */
  2054.     return (void *) realloc( (char *) ptr, size );
  2055.     }
  2056.  
  2057. #ifdef YY_USE_PROTOS
  2058. static void yy_flex_free( void *ptr )
  2059. #else
  2060. static void yy_flex_free( ptr )
  2061. void *ptr;
  2062. #endif
  2063.     {
  2064.     free( ptr );
  2065.     }
  2066.  
  2067. #if YY_MAIN
  2068. int main()
  2069.     {
  2070.     yylex();
  2071.     return 0;
  2072.     }
  2073. #endif
  2074.  
  2075. #line 184 "l.web2c"
  2076.  
  2077.